home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / tex / src / specialhost / specialwin.c < prev    next >
C/C++ Source or Header  |  1991-07-25  |  34KB  |  1,409 lines
  1. /* *** specialwin.c *** */
  2.  
  3.  
  4. #include "specialhost.h"
  5.  
  6. static struct TextFont    *font = NULL;
  7. static struct TextAttr    txtAttr;
  8.  
  9. #include "specialwin.h"
  10.  
  11.  
  12.  
  13. /**------------------*** Icon Data ***------------------**/
  14.  
  15. static USHORT  __chip imageData1[] = {
  16.  0x0000, 0x0000, 0x0000, 0x0000,
  17.  0x0000, 0x0000, 0x0000, 0x0001,
  18.  0x0000, 0x0000, 0x0000, 0x0001,
  19.  0x0000, 0x0000, 0x0000, 0x0001,
  20.  0x0000, 0x0000, 0x0000, 0x0001,
  21.  0x0000, 0x0000, 0x0000, 0x0001,
  22.  0x0000, 0x0000, 0x0000, 0x0001,
  23.  0x0000, 0x0000, 0x0000, 0x0001,
  24.  0x0000, 0x0000, 0x0000, 0x0001,
  25.  0x0000, 0x0000, 0x0000, 0x0001,
  26.  0x0000, 0x0000, 0x0000, 0x0001,
  27.  0x0000, 0x0000, 0x0000, 0x0001,
  28.  0x0000, 0x0000, 0x0000, 0x0001,
  29.  0x0000, 0x0000, 0x0000, 0x0001,
  30.  0x0000, 0x0000, 0x07FE, 0x0001,
  31.  0x0100, 0x0000, 0x0402, 0x0001,
  32.  0x0380, 0x0000, 0x07FE, 0x0001,
  33.  0x0540, 0x0000, 0x0402, 0x0001,
  34.  0x0100, 0x0000, 0x01DC, 0x0001,
  35.  0x0000, 0x0000, 0x0402, 0x0001,
  36.  0x0100, 0x0000, 0x07DA, 0x0001,
  37.  0x0100, 0x0000, 0x0400, 0x0001,
  38.  0x0100, 0x0000, 0x07DA, 0x0001,
  39.  0x0100, 0x00F7, 0x4402, 0x0001,
  40.  0x0100, 0x00C0, 0x41DA, 0x0001,
  41.  0x0100, 0x0092, 0x4402, 0x0001,
  42.  0x0100, 0x00A4, 0xC7FE, 0x0001,
  43.  0x011F, 0xF8C9, 0x4402, 0x0001,
  44.  0x0115, 0x5892, 0x47FE, 0x00C1,
  45.  0x011A, 0xA8A4, 0xC402, 0x0061,
  46.  0x1FFF, 0xFFFF, 0xFFFF, 0xFFF1,
  47.  0x0100, 0x0000, 0x0000, 0x0061,
  48.  0x0100, 0x0000, 0x0000, 0x00C1,
  49.  0x0000, 0x0000, 0x0000, 0x0001,
  50.  0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF,
  51. /**/
  52.  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  53.  0x8000, 0x0000, 0x0000, 0x0000,
  54.  0x8000, 0x0000, 0x0000, 0x0000,
  55.  0x8000, 0x0000, 0x0000, 0x0000,
  56.  0x8FFC, 0x0E1C, 0x0000, 0x0000,
  57.  0x88C4, 0x0B34, 0x0000, 0x0000,
  58.  0x80C0, 0x01E0, 0x0000, 0x0000,
  59.  0x80CF, 0xC0C0, 0x7800, 0x0000,
  60.  0x80CC, 0x41E0, 0x0000, 0x0000,
  61.  0x80CC, 0x0B34, 0x0000, 0x0000,
  62.  0x80CF, 0x8E1C, 0x0000, 0x0000,
  63.  0x800C, 0x0000, 0x0000, 0x0000,
  64.  0x800C, 0x4000, 0x0000, 0x0000,
  65.  0x800F, 0xC000, 0x0000, 0x0000,
  66.  0x8000, 0x0000, 0x07FE, 0x0000,
  67.  0x8100, 0x0000, 0x0402, 0x0000,
  68.  0x8380, 0x0000, 0x07FE, 0x0000,
  69.  0x8540, 0x0000, 0x0402, 0x0000,
  70.  0x8301, 0xC38F, 0x0FFF, 0x8800,
  71.  0x8102, 0x2448, 0x9526, 0x4800,
  72.  0x8182, 0x0448, 0x17FE, 0x4800,
  73.  0x8141, 0xC78F, 0x1427, 0xC800,
  74.  0x8120, 0x2408, 0x17FE, 0x4800,
  75.  0x8112, 0x24FF, 0xD526, 0x4900,
  76.  0x8109, 0xC4CF, 0x4FFE, 0x4F00,
  77.  0x8100, 0x0092, 0x4402, 0x0000,
  78.  0x8100, 0x00A4, 0xC7FE, 0x0000,
  79.  0x811F, 0xF8C9, 0x4402, 0x0000,
  80.  0x8115, 0x5892, 0x47FE, 0x00C0,
  81.  0x811A, 0xA8A4, 0xC402, 0x0060,
  82.  0x9FFF, 0xFFFF, 0xFFFF, 0xFFF0,
  83.  0x8100, 0x0000, 0x0000, 0x0060,
  84.  0x8100, 0x0000, 0x0000, 0x00C0,
  85.  0x8000, 0x0000, 0x0000, 0x0000,
  86.  0x0000, 0x0000, 0x0000, 0x0000,
  87. /**/
  88.  };
  89.  
  90. struct Image image1 = {
  91.   0,            /* LeftEdge */
  92.   0,            /* TopEdge */
  93.   ICON_WIDTH,        /* Width */
  94.   ICON_HEIGHT,        /* Height */
  95.   2,            /* Depth */
  96.   NULL,            /* ImageData */
  97.   0x3,            /* PlanePick */
  98.   0x0,            /* PlaneOnOff */
  99.   0,            /* [NextImage] */
  100.  };
  101.  
  102.  
  103.  
  104.  
  105. struct scroll_win  {
  106.     struct    scroll_text    *top;        /* first viewed line */
  107.     struct    scroll_text    *first_free;
  108.         long        number;        /* number of used lines in buffer */
  109.         long        displayed;    /* number of displayed lines */
  110.   };
  111.  
  112. struct scroll_text {
  113.         char        *line;
  114.     struct  scroll_text    *next_line;
  115.     struct  scroll_text    *prev_line;
  116.         short        is_first;    /* is first line in buffer */
  117.         short        is_last;    /* is last line in buffer */
  118.   };
  119.  
  120. #ifdef LATTICE
  121. extern    long    _stack;
  122. extern    char *    _procname;
  123. extern    long    _priority;
  124. extern    long    _BackGroundIO;
  125. extern    BPTR    _Backstdout;
  126. #endif
  127.  
  128. struct Library        *IFFBase    = NULL;
  129. struct GfxBase        *GfxBase    = NULL;
  130. struct IntuitionBase    *IntuitionBase    = NULL;
  131.  
  132. extern struct MsgPort         *special_port;
  133. extern IFFFILE            ifffile;
  134. extern struct BitMap        *bmap;
  135. extern short            use_blitter;
  136. extern short            invert_bmap;
  137. extern short            is_os2;
  138. extern short            ECS_chips;
  139.  
  140. static short            use_pubscr = FALSE;
  141.  
  142. static struct Window        *win = NULL;
  143. static UBYTE            sig_win;
  144. static struct Window        *icon = NULL;
  145. static struct scroll_win    swin;
  146. static           int        display_len;
  147. static           int        lines_to_show;
  148. static          int        height_char;
  149. static          int        width_char;
  150. static          int        icon_x_pos;
  151. static          int        icon_y_pos;
  152. static          int        win_x_pos;
  153. static          int        win_y_pos;
  154. static          int        win_width;
  155. static          int        win_height;
  156. static          int        win_title_height;
  157.  
  158. static          char        copyright[] = "SpecialHost Version "VERSION", last compiled: "__DATE__;
  159. static          char        PubScreenName[] = "ShowDVI-PubScr";
  160.  
  161.  
  162. static struct TagItem         pub_window_tags[] = {
  163.             { WA_ScreenTitle,    &(copyright[0])        },
  164.             { WA_AutoAdjust,    TRUE            },
  165.             { WA_PubScreenName,    &(PubScreenName[0])    },
  166.             { WA_PubScreenFallBack,    TRUE            },
  167.             { TAG_DONE,        0L            }
  168.         };
  169.  
  170.  
  171.  
  172. static void    OpenI            (void);
  173. static void    OpenG            (void);
  174. static void    OpenLib            (void);
  175. static void    CloseLib        (void);
  176. static void    CloseWin        (void);
  177. static int    get_wb_screen_data    (int *BarHeight);
  178. static void    CloseTopaz        (void);
  179. static void    OpenTopaz        (void);
  180. static void    CloseIcon        (void);
  181. static UBYTE    OpenIcon        (void);
  182. static UBYTE    OpenWin            (void);
  183. static UBYTE    ReOpenAll        (int draw_modus, int base_dpi);
  184. static void    refresh_draw_modus    (int draw_modus, int base_dpi);
  185. static void    set_picture_draw_modus    (long nr, int *draw_modus, int *base_dpi);
  186. static void    DrawWin            (void);
  187. static long    keys            (struct IntuiMessage *msg);
  188. static void    getShowDVI        (void);
  189. static long    WindowMessage        (int *draw_modus, int *base_dpi);
  190. static void    init_text        (void);
  191. static void    DisplayText        (void);
  192. static void    ScrollUp        (void);
  193. static void    ScrollDown        (void);
  194. static FILE    *OpenConfigFile        (char *name, char *modus);
  195. static void    ReadConfig        (int *draw_modus, int *base_dpi);
  196. static void    SaveConfig        (int draw_modus, int base_dpi);
  197.  
  198.  
  199.  
  200.  
  201. void close_all(void)
  202. {
  203.   close_port_bitm();
  204.   CloseWin();
  205.   CloseIcon();
  206.   CloseTopaz();
  207.   CloseLib();
  208.   if (_Backstdout) {
  209.     Close(_Backstdout);
  210.     _Backstdout = NULL;
  211.   }
  212. }
  213.  
  214. void Fatal(int nr)
  215. {
  216.   long ret;
  217.   char *message;
  218.   char str[64];
  219.   
  220.   switch (nr) {
  221.     case NO_INTUI:
  222.         message = "can't open Intuition-Library!";
  223.         ret = 20;
  224.         break;
  225.     case NO_GFX:
  226.         message = "can't open Graphics-Library!";
  227.         ret = 20;
  228.         break;
  229.     case LINE_TO_LONG:
  230.         message = "line too long!!!";
  231.         ret = 20;
  232.         break;
  233.     case NO_WIN:
  234.         message = "can't open window!";
  235.         ret = 15;
  236.         break;
  237.     case NO_ICON:
  238.         message = "can't open icon-window!";
  239.         ret = 15;
  240.         break;
  241.     case NO_MEMORY:
  242.         message = "not enough memory!";
  243.         ret = 15;
  244.         break;
  245.     case NOT_FIRST:
  246.     message = "SpecialHost already running!";
  247.     ret = 5;
  248.     break;
  249.     case NO_PORT:
  250.         message = "can't open message-port!";
  251.         ret = 10;
  252.         break;
  253.     case NO_MESSAGE:
  254.         message = "signal without message??";
  255.         ret = 15;
  256.         break;
  257.     case NO_MEM:
  258.         message = "no memory!";
  259.         ret = 10;
  260.         break;
  261.     case NO_OK_BIT:
  262.         message = "expect AC_OK_BITMAP!";
  263.         ret = 10;
  264.         break;
  265.     default:
  266.         message = "unknown error!?";
  267.         ret = 20;
  268.         break;
  269.   }
  270.   sprintf(str, "Fatal: %s\n", message);
  271.  
  272.   if (_Backstdout) {
  273.     Write(_Backstdout, str, strlen(str));
  274.   }
  275.   else {
  276.     if (win != NULL) {
  277.       pline(message);    /* a little bit hacky!!!! */
  278.       Delay(50);
  279.     }
  280.   }
  281.  
  282.   close_all();
  283.   exit(ret);
  284. }
  285.  
  286. static void OpenI(void)
  287. {
  288.   IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
  289.   if (IntuitionBase==NULL) {
  290.     Fatal(NO_INTUI);
  291.   }
  292.   is_os2 = IntuitionBase->LibNode.lib_Version >= 36L;
  293. }
  294.  
  295. static void OpenG(void)
  296. {
  297.   GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0);
  298.   if (GfxBase==NULL) {
  299.     Fatal(NO_GFX);
  300.   }
  301.   if (is_os2) {
  302.     ECS_chips = GfxBase->ChipRevBits0;
  303.   }
  304. }
  305.  
  306. static void OpenLib(void)
  307. {
  308. #ifndef LATTICE
  309.   int bytes;
  310. #endif
  311.  
  312.   OpenI();
  313.   OpenG();
  314.  
  315. #ifdef LATTICE
  316.   image1.ImageData = (USHORT *)&imageData1;
  317. #else
  318.   bytes = ICON_HEIGHT * ICON_WIDTH * 2 / 8;
  319.   image1.ImageData = AllocMem(bytes, MEMF_CHIP | MEMF_PUBLIC);
  320.   if (image1.ImageData == NULL) {
  321.     Fatal(NO_MEMORY);
  322.   }
  323.   memcpy((char *)image1.ImageData, (char *)imageData1, bytes);
  324. #endif
  325. }
  326.  
  327. static void CloseLib(void)
  328. {
  329. #ifndef LATTICE
  330.   if (image1.ImageData) != NULL) {
  331.     FreeMem(image1.ImageData, ICON_HEIGHT * ICON_WIDTH * 2 / 8);
  332.   }
  333. #endif
  334.  
  335.   if (IFFBase != NULL) CloseLibrary(IFFBase);
  336.   if (IntuitionBase != NULL) CloseLibrary((struct Library *)IntuitionBase);
  337.   if (GfxBase != NULL) CloseLibrary((struct Library *)GfxBase);
  338. }
  339.  
  340. static void CloseWin(void)
  341. {
  342.   struct Message *msg;
  343.  
  344.   if (win != NULL) {
  345.     ClearMenuStrip(win);
  346.     win_x_pos  = win->LeftEdge;
  347.     win_y_pos  = win->TopEdge;
  348.     win_width  = win->Width;
  349.     win_height = win->Height;
  350.  
  351.     Forbid();
  352.     do {
  353.       msg = GetMsg(win->UserPort);
  354.       if (msg != NULL) ReplyMsg(msg);
  355.     } while (msg != NULL);
  356.     ModifyIDCMP(win, 0);
  357.     Permit();
  358.     
  359.     CloseWindow(win);
  360.     win = NULL;
  361.   }
  362. }
  363.  
  364.  
  365. static void CloseTopaz(void)
  366. {
  367.   if (font != NULL) {
  368.     CloseFont(font);
  369.     font = NULL;
  370.   }
  371. }
  372.  
  373. static void OpenTopaz(void)
  374. {
  375.   txtAttr.ta_Name  = (STRPTR)FONTNAME;
  376.   txtAttr.ta_YSize = FONTYSIZE;
  377.   txtAttr.ta_Style = FONTSTYLE;
  378.   txtAttr.ta_Flags = FONTFLAGS;
  379.   font = OpenFont(&txtAttr);
  380. }
  381.  
  382.  
  383. static int get_wb_screen_data(int *BarHeight)
  384. {
  385.   struct Screen hscr;
  386.   int res = 0;
  387.  
  388.   res = GetScreenData((char *)&hscr, (long)sizeof(hscr), (long)WBENCHSCREEN, IntuitionBase->ActiveScreen);
  389.   if (res) {
  390.     *BarHeight = hscr.BarHeight;
  391.   }
  392.   return (res);
  393. }
  394.  
  395.  
  396.  
  397. /*--------------------------------------------*/
  398. static struct Gadget dragit =
  399.    { 0,0, 0, 0, 0,GADGIMAGE|GADGHIMAGE|GRELWIDTH|GRELHEIGHT,GADGIMMEDIATE,
  400.    WDRAGGING, (APTR)&image1, (APTR)&image1,0,0,0,0,0 };
  401.  
  402. static struct NewWindow NewWI = {
  403.    0, 0, 0, 0, 2,0, GADGETDOWN,
  404.    SMART_REFRESH | BORDERLESS | NOCAREREFRESH,
  405.    NULL, NULL, NULL, NULL, NULL, 0,0,0,0, WBENCHSCREEN
  406. };
  407.  
  408. static void CloseIcon(void)
  409. {
  410.   if (icon != NULL) {
  411.     RemoveGadget(icon,&dragit);
  412.     icon_x_pos = icon->LeftEdge;
  413.     icon_y_pos = icon->TopEdge;
  414.     CloseWindow(icon);
  415.     icon = NULL;
  416.   }
  417. }
  418.  
  419. static UBYTE OpenIcon(void)
  420. {
  421.   dragit.Height  = ICON_HEIGHT;
  422.   NewWI.Height   = ICON_HEIGHT;
  423.   NewWI.Width    = ICON_WIDTH;
  424.   NewWI.LeftEdge = icon_x_pos;
  425.   NewWI.TopEdge  = icon_y_pos;
  426.  
  427.   if (is_os2 && use_pubscr) {
  428.     NewWI.Type = PUBLICSCREEN;
  429.     icon = OpenWindowTagList(&NewWI, &(pub_window_tags[0]));
  430.   }
  431.   else {
  432.     icon = OpenWindow(&NewWI);
  433.   }
  434.   if (icon == NULL) {
  435.     Fatal(NO_ICON);
  436.   }
  437.  
  438.   if (font != NULL) {
  439.     SetFont(icon->RPort, font);        /* set all to my font */
  440.   }
  441.  
  442.   AddGList(icon,&dragit,0,1,0);
  443.   RefreshGadgets(&dragit,icon,0);
  444.   
  445.   SetWindowTitles(icon, (UBYTE *) ~0, &(copyright[0]));
  446.  
  447.   return icon->UserPort->mp_SigBit;
  448. }
  449. /*--------------------------------------------*/
  450.  
  451.  
  452.  
  453. static UBYTE OpenWin(void)
  454. {
  455.   struct NewWindow new_win; 
  456.   struct Screen *scr;
  457.  
  458. #if 0
  459.   if (use_blitter) {
  460.     Blitter_Gad.Flags |= SELECTED;
  461.   }
  462.   else {
  463.     Blitter_Gad.Flags &= ~SELECTED;
  464.   }
  465.   if (invert_bmap) {
  466.     Invert_Gad.Flags |= SELECTED;
  467.   }
  468.   else {
  469.     Invert_Gad.Flags &= ~SELECTED;
  470.   }
  471. #endif
  472.  
  473.   new_win.LeftEdge = win_x_pos;
  474.   new_win.TopEdge  = win_y_pos;
  475.   new_win.Width = win_width;
  476.   new_win.Height = win_height;
  477.   new_win.DetailPen = 0;
  478.   new_win.BlockPen = 1;
  479.   new_win.Title = (STRPTR)WIN_TITLE;
  480.   new_win.Flags = WINDOWCLOSE | ACTIVATE | WINDOWSIZING | WINDOWDEPTH | 
  481.             WINDOWDRAG | /* SMART_REFRESH */ SIMPLE_REFRESH /*| GIMMEZEROZERO*/;
  482.   new_win.IDCMPFlags = WIN_IDCMP_FLAGS;
  483.   new_win.Type = WBENCHSCREEN;
  484.   new_win.FirstGadget = &Blitter_Gad;
  485.   new_win.CheckMark = NULL;
  486.   new_win.Screen = NULL;
  487.   new_win.BitMap = NULL;
  488.   new_win.MinWidth  = WIN_X_MIN_WIDTH;
  489.   new_win.MinHeight = WIN_X_MIN_HEIGHT;
  490.   new_win.MaxWidth  = WIN_X_MAX_WIDTH;
  491.   new_win.MaxHeight = WIN_X_MAX_HEIGHT;
  492.  
  493.   if (is_os2 && use_pubscr) {
  494.     scr = LockPubScreen(&(PubScreenName[0]));
  495.     if (scr == NULL) {
  496.       use_pubscr = FALSE;
  497.       pline("Can't find the public-screen \"%s\"!", &(PubScreenName[0]));
  498.     }
  499.   }
  500.   if (is_os2 && use_pubscr) {
  501.     new_win.Type = PUBLICSCREEN;
  502.     win = OpenWindowTagList(&new_win, &(pub_window_tags[0]));
  503.     UnlockPubScreen(NULL, scr);
  504.   }
  505.   else {
  506.     win = OpenWindow(&new_win);
  507.   }
  508.   if (win == NULL) {
  509.      Fatal(NO_WIN);
  510.   }
  511.   if (font != NULL) {
  512.     SetFont(win->RPort, font);        /* set all to my font */
  513.   }
  514.   
  515.   if (is_os2) {
  516.     MenItem[7].Flags |= ITEMENABLED;
  517.     if (use_pubscr) {
  518.       MenItem[7].Flags |= CHECKED;
  519.     }
  520.     else {
  521.       MenItem[7].Flags &= ~CHECKED;
  522.     }
  523.   }
  524.   else {
  525.     MenItem[7].Flags &= ~ITEMENABLED;
  526.   }
  527.  
  528.   SetMenuStrip(win, &SpecialMenu[0]);
  529.   
  530.   if (!(is_os2 && use_pubscr)) {
  531.     SetWindowTitles(win, (UBYTE *) ~0, &(copyright[0]));
  532.   }
  533.  
  534.   return win->UserPort->mp_SigBit;
  535. }
  536.  
  537.  
  538. static UBYTE ReOpenAll(int draw_modus, int base_dpi)
  539. {
  540.   UBYTE sig = 0;
  541.  
  542.   if (win != NULL) {
  543.     CloseWin();
  544.     sig = OpenWin();
  545.     DrawWin();
  546.     refresh_draw_modus(draw_modus, base_dpi);
  547.     DisplayText();
  548.   }
  549.   return sig;
  550. }
  551.  
  552.  
  553.  
  554. static void DrawWin(void)
  555. {
  556.   struct RastPort *rp;
  557.   long start = START_PRINTING + win_title_height - 10;
  558.  
  559.   if (win == NULL) return;
  560.  
  561.   rp = win->RPort;
  562.  
  563.   /**
  564.   Move(rp,2,start);
  565.   Draw(rp,win->Width-3,start);
  566.   Move(rp,2,start-10);
  567.   Draw(rp,win->Width-3,start-10);
  568.   **/
  569.  
  570.   SetAPen(rp, 3);
  571.   Move(rp,win->BorderLeft,start);
  572.   Draw(rp,win->Width - win->BorderLeft - win->BorderRight+1,start);
  573.   Move(rp,win->BorderLeft,start-10);
  574.   Draw(rp,win->Width - win->BorderLeft - win->BorderRight+1,start-10);
  575. }
  576.  
  577. static long keys(struct IntuiMessage *msg)
  578. {
  579.   ULONG Code, Qualifier;
  580.   long ret = 0;
  581.  
  582.   Code = msg->Code;
  583.   Qualifier = msg->Qualifier;
  584.  
  585.   if (!(Code & 128)) {
  586.     switch (Code) {
  587.       case CURSORUP:
  588.     ScrollUp();
  589.         break;
  590.       case CURSORDOWN:
  591.         ScrollDown();
  592.         break;
  593.       case 51:            /* c */
  594.         if (Qualifier & IEQUALIFIER_CONTROL) {
  595.           ret = 10;
  596.         }
  597.       default:
  598.         break;
  599.     }
  600.   }
  601.   
  602.   return ret;
  603. }
  604.  
  605. static void getShowDVI(void)
  606. {
  607.   struct Process *my_proc;
  608.  
  609.   if ((my_proc = (struct Process *)FindTask("ShowDVI-Task")) != NULL) {
  610.     Signal(&(my_proc->pr_Task),SIGBREAKF_CTRL_E);    /* screen to front */
  611.   }
  612.   else {
  613.     pline("*** ShowDVI is not active!");
  614.   }
  615. }
  616.  
  617.  
  618. static long WindowMessage(int *draw_modus, int *base_dpi)
  619. {
  620.   struct IntuiMessage *msg;
  621.   long gnr;
  622.   long ret = 0;
  623.   UWORD sel;
  624.   UBYTE MenuNum, ItemNum;
  625.   struct MenuItem *ItemAdr;
  626.  
  627.   while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)) != NULL) {
  628.     switch (msg->Class) {
  629.     case CLOSEWINDOW:
  630.         ret = 10;
  631.         break;
  632.     case MENUPICK:
  633.         sel = msg->Code;
  634.         while (sel != MENUNULL) {
  635.           MenuNum = MENUNUM(sel);
  636.           ItemNum = ITEMNUM(sel);
  637.           switch (MenuNum) {
  638.             case 0:
  639.               switch (ItemNum) {
  640.                 case 0:            /* about */
  641.               pline("----------------------------------------------------");
  642.               pline(&(copyright[0]));
  643.               pline("Copyright© 90/91 Georg Heßmann. All Rights Reserved.");  
  644.               pline("----------------------------------------------------");
  645.                   break;
  646.                 case 2:            /* read cnf */
  647.                   ReadConfig(draw_modus, base_dpi);
  648.                   break;
  649.                 case 3:            /* save cnf */
  650.                   SaveConfig(*draw_modus, *base_dpi);
  651.                   break;
  652.                 case 5:            /* ShowDVI */
  653.                   getShowDVI();
  654.                   break;
  655.                 case 6:            /* icon */
  656.                   ret = 3;
  657.                   break;
  658.                 case 7:            /* use pubscreen */
  659.                   use_pubscr = !use_pubscr;
  660.                   /* nun wird das Window zugemacht!! Also Message zurueck und *keine* mehr holen!! */
  661.                   ReplyMsg(&(msg->ExecMessage));
  662.                   ReOpenAll(*draw_modus, *base_dpi);
  663.                   return ret;        /* wichtig, sonst GURU */
  664.                   break;
  665.                 case 9:            /* quit */
  666.                   ret = 10;
  667.                   break;
  668.               }
  669.               break;
  670.             case 1:
  671.               switch (ItemNum) {
  672.                 case 0:            /* memory */
  673.                   *draw_modus = DRAW_IN_MEM;
  674.                   break;
  675.                 case 1:            /* file */
  676.                   *draw_modus = DRAW_FILE;
  677.                   break;
  678.                 case 2:            /* memory-border */
  679.                   *draw_modus = DRAW_IN_MEM_B;
  680.                   break;
  681.                 case 3:            /* file-border */
  682.                   *draw_modus = DRAW_FILE_B;
  683.                   break;
  684.                 case 4:            /* border */
  685.                   *draw_modus = DRAW_BORDER;
  686.                   break;
  687.                 case 5:            /* rectangle */
  688.                   *draw_modus = DRAW_RECT;
  689.                   break;
  690.               }
  691.               refresh_draw_modus(*draw_modus, *base_dpi);
  692.               break;
  693.             case 2:
  694.               switch (ItemNum) {
  695.                 case 0:            /* invert */
  696.                   invert_bmap = !invert_bmap;
  697.               if (invert_bmap) {
  698.                 Invert_Gad.Flags |= SELECTED;
  699.                 pline("Invert b&w bitmap");
  700.               }
  701.               else {
  702.                 Invert_Gad.Flags &= ~SELECTED;
  703.                 pline("Use original b&w bitmap");
  704.               }
  705.               RefreshGadgets(&Invert_Gad, win, NULL);
  706.                   break;
  707.                 case 1:            /* blitter */
  708.                   use_blitter = !use_blitter;
  709.               if (use_blitter) {
  710.                 Blitter_Gad.Flags |= SELECTED;
  711.                 pline("Use Blitter for b&w scaling (if possible)");
  712.               }
  713.               else {
  714.                 Blitter_Gad.Flags &= ~SELECTED;
  715.                 pline("Use software routine for b&w scaling");
  716.               }
  717.               RefreshGadgets(&Blitter_Gad, win, NULL);
  718.                   break;
  719.               }
  720.               break;
  721.           }
  722.           ItemAdr = ItemAddress(&SpecialMenu[0], sel);
  723.           sel = ItemAdr->NextSelect;
  724.         }
  725.         break;
  726.     case MOUSEBUTTONS:
  727.         /* not used */
  728.         if (msg->Code == MENUDOWN) {
  729.           ;
  730.         }
  731.         else {
  732.           if (msg->Code == SELECTDOWN) {
  733.             ;
  734.           }
  735.         }
  736.         break;
  737.     case GADGETUP:
  738.         gnr = ((struct Gadget *)(msg->IAddress))->GadgetID;
  739.         switch (gnr) {
  740.           case NR_TOICON_GAD:
  741.             ret = 3;
  742.             break;
  743.           case NR_SHOW_GAD:
  744.               getShowDVI();
  745.             break;
  746.           case NR_INVERT_GAD:
  747.               invert_bmap = !invert_bmap;
  748.             if (invert_bmap) {
  749.               pline("Invert b&w bitmap");
  750.               Invert_Gad.Flags |= SELECTED;
  751.               MenItem[INVERTNR].Flags |= CHECKED;
  752.             }
  753.             else {
  754.               pline("Use original b&w bitmap");
  755.               Invert_Gad.Flags &= ~SELECTED;
  756.               MenItem[INVERTNR].Flags &= ~CHECKED;
  757.             }
  758.                 RefreshGadgets(&Invert_Gad, win, NULL);
  759.             break;
  760.           case NR_BLITTER_GAD:
  761.               use_blitter = !use_blitter;
  762.             if (use_blitter) {
  763.               pline("Use Blitter for b&w scaling (if possible)");
  764.               Blitter_Gad.Flags |= SELECTED;
  765.               MenItem[BLITTERNR].Flags |= CHECKED;
  766.             }
  767.             else {
  768.               pline("Use software routine for b&w scaling");
  769.               Blitter_Gad.Flags &= ~SELECTED;
  770.               MenItem[BLITTERNR].Flags &= ~CHECKED;
  771.             }
  772.                 RefreshGadgets(&Blitter_Gad, win, NULL);
  773.             break;
  774.           default:
  775.             set_picture_draw_modus(gnr, draw_modus, base_dpi);
  776.             refresh_draw_modus(*draw_modus, *base_dpi);
  777.             break;
  778.         }
  779.         break;
  780.     case NEWSIZE:
  781.     case REFRESHWINDOW:
  782.         DisplayText();
  783.         DrawWin();
  784.         refresh_draw_modus(*draw_modus, *base_dpi);
  785.         break;
  786.     case RAWKEY:
  787.         ret = keys(msg);
  788.         break;
  789.     default:
  790.         pline("*** unknown message (%d)\n",msg->Class);
  791.     }
  792.     ReplyMsg(&(msg->ExecMessage));
  793.   }
  794.   return ret;
  795. }
  796.  
  797.  
  798. static void set_picture_draw_modus(long nr, int *draw_modus, int *base_dpi)
  799. {
  800.   switch(nr) {
  801.     case NR_MEM_GAD:
  802.         *draw_modus = DRAW_IN_MEM;
  803.         break;
  804.     case NR_FILE_GAD:
  805.         *draw_modus = DRAW_FILE;
  806.         break;
  807.     case NR_MEM_B_GAD:
  808.         *draw_modus = DRAW_IN_MEM_B;
  809.         break;
  810.     case NR_FILE_B_GAD:
  811.         *draw_modus = DRAW_FILE_B;
  812.         break;
  813.     case NR_BORDER_GAD:
  814.         *draw_modus = DRAW_BORDER;
  815.         break;
  816.     case NR_RECT_GAD:
  817.         *draw_modus = DRAW_RECT;
  818.         break;
  819.     case NR_INT_GAD:
  820.         *base_dpi = ((struct StringInfo *)(Bdpi_Gad.SpecialInfo))->LongInt;
  821.         pline("Set base dpi to %d",*base_dpi);
  822.         break;
  823.     default:
  824.         pline("Unknown Gadget %d!\n",nr);
  825.   }
  826. }
  827.  
  828.  
  829.  
  830. static void refresh_draw_modus(int draw_modus, int base_dpi)
  831. {
  832.   register struct RastPort *rp;
  833.   struct StringInfo *si;
  834.   char *iBuf, *iuBuf;
  835.   int i;
  836.  
  837.   if (win == NULL) return;    /* wird fuers erste ReadConfig gebraucht!!! */
  838.  
  839.   rp = win->RPort;
  840.   SetAPen(rp, 3);
  841.  
  842.   for (i=STARTDRAW; i<STARTDRAW+6; i++) {
  843.     MenItem[i].Flags &= (~CHECKED);
  844.   }
  845.  
  846.   Memory_Gad.Flags   &= ~SELECTED;
  847.   File_Gad.Flags     &= ~SELECTED;
  848.   Memory_B_Gad.Flags &= ~SELECTED;
  849.   File_B_Gad.Flags   &= ~SELECTED;
  850.   Border_Gad.Flags   &= ~SELECTED;
  851.   Rect_Gad.Flags     &= ~SELECTED;
  852.  
  853.   Move(rp, 20, START_PRINTING + win_title_height - 10 -2);
  854.   switch(draw_modus) {
  855.     case DRAW_IN_MEM:
  856.         Text(rp,"Transfer picture in memory                   ",45);
  857.         MenItem[STARTDRAW].Flags |= CHECKED;
  858.         Memory_Gad.Flags |= SELECTED;
  859.         break;
  860.     case DRAW_FILE:
  861.         Text(rp,"Transfer picture in a file                   ",45);
  862.         MenItem[STARTDRAW+1].Flags |= CHECKED;
  863.         File_Gad.Flags    |= SELECTED;
  864.         break;
  865.     case DRAW_IN_MEM_B:
  866.         Text(rp,"Transfer picture in memory (draw with border)",45);
  867.         MenItem[STARTDRAW+2].Flags  |= CHECKED;
  868.         Memory_B_Gad.Flags |= SELECTED;
  869.         break;
  870.     case DRAW_FILE_B:
  871.         Text(rp,"Transfer picture in a file (draw with border)",45);
  872.         MenItem[STARTDRAW+3].Flags |= CHECKED;
  873.         File_B_Gad.Flags  |= SELECTED;
  874.         break;
  875.     case DRAW_BORDER:
  876.         Text(rp,"Draw only a border                           ",45);
  877.         MenItem[STARTDRAW+4].Flags |= CHECKED;
  878.         Border_Gad.Flags  |= SELECTED;
  879.         break;
  880.     case DRAW_RECT:
  881.         Text(rp,"Draw only a filled rectangle                 ",45);
  882.         MenItem[STARTDRAW+5].Flags |= CHECKED;
  883.         Rect_Gad.Flags    |= SELECTED;
  884.         break;
  885.     default:
  886.         pline("*** Unknown draw mode %d!\n",draw_modus);
  887.         break;
  888.   }
  889.  
  890.   si = (struct StringInfo *)Bdpi_Gad.SpecialInfo;
  891.   iBuf = (char *)si->Buffer;
  892.   iuBuf = (char *)si->UndoBuffer;
  893.   sprintf(iBuf,"%d",base_dpi);
  894.   sprintf(iuBuf,"%d",base_dpi);
  895.   si->LongInt = (long)base_dpi;
  896.  
  897.   RefreshGadgets(&Bdpi_Gad, win, NULL);
  898. }
  899.  
  900.  
  901. static void init_text (void)
  902. {
  903.   struct scroll_text *entry, *entry2, *first_entry;
  904.   char *block;
  905.   int i;
  906.  
  907.   block = malloc(NR_TEXT_LINES * (LINE_LENGTH+1) * sizeof(char));
  908.   if (block == NULL) {
  909.     Fatal(NO_MEMORY);
  910.   }
  911.  
  912.   memset(block,0,NR_TEXT_LINES * (LINE_LENGTH+1) * sizeof(char));
  913.   
  914.   first_entry = entry2 = NULL;
  915.  
  916.   for (i=0; i<NR_TEXT_LINES; i++) {
  917.     if ((entry = malloc(sizeof(struct scroll_text))) == NULL) {
  918.       Fatal(NO_MEMORY);
  919.     }
  920.     entry->is_first = FALSE;
  921.     entry->is_last = FALSE;
  922.     entry->next_line = entry2;
  923.     if (entry2 != NULL) {
  924.       entry2->prev_line = entry;
  925.     }
  926.     entry->line = block;
  927.     block += LINE_LENGTH+1;
  928.     entry2 = entry;
  929.     if (i == 0) {
  930.       first_entry = entry;
  931.     }
  932.   }
  933.   first_entry->next_line = entry2;
  934.   entry2->prev_line = first_entry;
  935.   swin.top = swin.first_free = first_entry;
  936.   swin.number = 0;
  937.   swin.displayed = 0;
  938. }
  939.  
  940.  
  941. void __stdargs pline(char *format,...)
  942. {
  943.   volatile va_list argptr;
  944.   char maxline[5*LINE_LENGTH+1];        /* about 500 bytes stack! */
  945.   char *ptr;
  946.   int i, j, len;
  947.   
  948.   va_start(argptr, format);
  949.   vsprintf(maxline, format, argptr);
  950.   va_end(argptr);
  951.  
  952.   len = strlen(maxline);
  953.   if (len >5*LINE_LENGTH+1) {
  954.     Fatal(LINE_TO_LONG);        /* trashing the stack !! */
  955.   }
  956.  
  957.   if (len > display_len) {
  958.     strncpy(swin.first_free->line,maxline,display_len);
  959.     if (swin.first_free->is_first) {
  960.       swin.first_free->is_first = FALSE;
  961.       swin.first_free->next_line->is_first = TRUE;
  962.     }
  963.     if (swin.first_free->prev_line->is_last) {
  964.       swin.first_free->prev_line->is_last = FALSE;
  965.       swin.first_free->is_last = TRUE;
  966.     }
  967.     swin.first_free = swin.first_free->next_line;
  968.     swin.displayed ++;
  969.     if (swin.displayed > lines_to_show) {
  970.       swin.top = swin.top->next_line;
  971.       swin.displayed --;
  972.     }
  973.     swin.number++;
  974.     DisplayText();
  975.     len -= display_len;
  976.     ptr = maxline + display_len;
  977.     for (i=0; i < len / (display_len-1)+1; i++) {
  978.       *swin.first_free->line = '+';
  979.       strncpy(swin.first_free->line+1,ptr,display_len-1);
  980.       for (j=strlen(swin.first_free->line); j<LINE_LENGTH; j++) {
  981.         swin.first_free->line[j] = ' ';
  982.       }
  983.       swin.first_free->line[LINE_LENGTH] = '\0';
  984.       ptr += display_len - 1;
  985.       if (swin.first_free->is_first) {
  986.         swin.first_free->is_first = FALSE;
  987.         swin.first_free->next_line->is_first = TRUE;
  988.       }
  989.       if (swin.first_free->prev_line->is_last) {
  990.         swin.first_free->prev_line->is_last = FALSE;
  991.         swin.first_free->is_last = TRUE;
  992.       }
  993.       swin.first_free = swin.first_free->next_line;
  994.       swin.displayed ++;
  995.       if (swin.displayed > lines_to_show) {
  996.         swin.top = swin.top->next_line;
  997.         swin.displayed --;
  998.       }
  999.       swin.number++;
  1000.       DisplayText();
  1001.     }
  1002.   }
  1003.   else {
  1004.     for (i=len; i<LINE_LENGTH; i++) {
  1005.       maxline[i] = ' ';
  1006.     }
  1007.     maxline[LINE_LENGTH] = '\0';
  1008.     strcpy(swin.first_free->line,maxline);
  1009.     if (swin.first_free->is_first) {
  1010.       swin.first_free->is_first = FALSE;
  1011.       swin.first_free->next_line->is_first = TRUE;
  1012.     }
  1013.     if (swin.first_free->prev_line->is_last) {
  1014.       swin.first_free->prev_line->is_last = FALSE;
  1015.       swin.first_free->is_last = TRUE;
  1016.     }
  1017.     swin.first_free = swin.first_free->next_line;
  1018.     swin.displayed ++;
  1019.     if (swin.displayed >= lines_to_show) {
  1020.       swin.top = swin.top->next_line;
  1021.       swin.displayed --;
  1022.     }
  1023.     swin.number++;
  1024.     DisplayText();
  1025.   }
  1026. }
  1027.  
  1028.  
  1029. static void ScrollUp(void)
  1030. {
  1031.   if (swin.number > swin.displayed && !swin.top->is_first) {
  1032.     swin.top = swin.top->prev_line;
  1033.     DisplayText();
  1034.   }
  1035. }
  1036.  
  1037. static void ScrollDown(void)
  1038. {
  1039.   struct scroll_text *entry;
  1040.   int i;
  1041.  
  1042.   entry = swin.top;
  1043.   for (entry = swin.top, i=0; !entry->is_last && i<lines_to_show; i++, entry=entry->next_line);
  1044.  
  1045.   if (i == lines_to_show) {
  1046.     swin.top = swin.top->next_line;
  1047.     DisplayText();
  1048.   }
  1049. }
  1050.  
  1051.  
  1052.  
  1053. static void DisplayText(void)
  1054. {
  1055.   struct RastPort *rp;
  1056.   int i, len, more;
  1057.   long x, y;
  1058.   struct scroll_text *entry;
  1059.   long start = START_PRINTING + win_title_height - 10;
  1060.  
  1061.   if (win == NULL) return;    /* ! */
  1062.  
  1063.   rp = win->RPort;
  1064.  
  1065.   SetAPen(rp, 1);
  1066.  
  1067.   display_len = (win->Width - win->BorderLeft - win->BorderRight - 4) / width_char;
  1068.   lines_to_show = (win->Height - win->BorderBottom - start - 3) / height_char;
  1069.  
  1070.   more = lines_to_show - swin.displayed;
  1071.   if (more >= 0) {
  1072.     if (swin.displayed + more > swin.number) {
  1073.       more = swin.number - swin.displayed;
  1074.     }
  1075.     for (i=0; i<more && !swin.top->is_first; i++) {
  1076.       swin.top = swin.top->prev_line;
  1077.     }
  1078.     swin.displayed += more;
  1079.   }
  1080.   else {
  1081.     for (i=0; i>more && !swin.top->is_last; i--) {
  1082.       swin.top = swin.top->next_line;
  1083.     }
  1084.     swin.displayed += more;
  1085.   }
  1086.  
  1087.   x = win->BorderLeft+2;
  1088.   y = start+height_char;;
  1089.  
  1090.   entry = swin.top;
  1091.   for (i=0; i<lines_to_show; i++) {
  1092.     if (entry == swin.first_free) {
  1093.       break;
  1094.     }
  1095.     len = strlen(entry->line);
  1096.     if (len > 0) {
  1097.       if (len > display_len) {
  1098.         len = display_len;
  1099.       }
  1100.       Move(rp,x,y);
  1101.       Text(rp,entry->line,len);
  1102.     }
  1103.     y += height_char;
  1104.     entry = entry->next_line;
  1105.   }
  1106.  
  1107.   if (swin.number > NR_TEXT_LINES) {
  1108.     swin.number = NR_TEXT_LINES;
  1109.   }
  1110. }
  1111.  
  1112.  
  1113. static FILE *OpenConfigFile(char *name, char *modus)
  1114. {
  1115.   register char *ptr;
  1116.   char path[120], env[120];
  1117.   FILE *fp = NULL;
  1118.   int len;
  1119.   
  1120.   ptr = getenv("TEXCONFIG");
  1121.   if (ptr == NULL) ptr = "TeX:config";
  1122.   strcpy(env, ptr);
  1123.   
  1124.   ptr = strtok(env, ",;");
  1125.   do {
  1126.     strcpy(path, ptr);
  1127.     len = strlen(path);
  1128.     if (path[len-1] != ':' && path[len-1] != '/') {
  1129.       path[len]   = '/';
  1130.       path[len+1] = '\0';
  1131.     }
  1132.     if (strcmp(path, "./") == 0) path[0] = '\0';    /* ./ is actual directory */
  1133.     strcat(path, name);
  1134.     fp = fopen(path, modus);
  1135.   } while (fp == NULL && (ptr = strtok(NULL, ",;")) != NULL);
  1136.   
  1137.   return fp;
  1138. }
  1139.  
  1140.  
  1141.  
  1142. static void ReadConfig(int *draw_modus, int *base_dpi)
  1143. {
  1144.   FILE *f;
  1145.   struct config_struct cnf;
  1146.   short old_use_pubscr = use_pubscr;
  1147.  
  1148.   if ((f = OpenConfigFile("SpecialHost.config", "r")) != NULL) {
  1149.     if (fread((char*)&cnf, sizeof(cnf), 1, f) == 1) {
  1150.       if (!(cnf.magic != CONFIG_FILE_MAGIC || cnf.version > CONFIG_FILE_VERSION)) {
  1151.         use_blitter = cnf.use_blitter;
  1152.         invert_bmap = cnf.invert_bmap;
  1153.         *base_dpi   = cnf.base_dpi;
  1154.         *draw_modus = cnf.draw_modus;
  1155.         icon_x_pos  = cnf.icon_x_pos;
  1156.         icon_y_pos  = cnf.icon_y_pos;
  1157.         win_x_pos   = cnf.win_x_pos;
  1158.         win_y_pos   = cnf.win_y_pos;
  1159.         win_width   = cnf.win_width;
  1160.         win_height  = cnf.win_height;
  1161.         use_pubscr  = cnf.use_pubscr;
  1162.       }
  1163.     }
  1164.     fclose(f);
  1165.   }
  1166.   
  1167.   if (invert_bmap) {
  1168.     MenItem[INVERTNR].Flags |= CHECKED;
  1169.     Invert_Gad.Flags |= SELECTED;
  1170.   }
  1171.   else {
  1172.     MenItem[INVERTNR].Flags &= ~CHECKED;
  1173.     Invert_Gad.Flags &= ~SELECTED;
  1174.   }
  1175.  
  1176.   if (use_blitter) {
  1177.     MenItem[BLITTERNR].Flags |= CHECKED;
  1178.     Blitter_Gad.Flags |= SELECTED;
  1179.   }
  1180.   else {
  1181.     MenItem[BLITTERNR].Flags &= ~CHECKED;
  1182.     Blitter_Gad.Flags &= ~SELECTED;
  1183.   }
  1184.   
  1185.   if (win != NULL && use_pubscr != old_use_pubscr) {
  1186.     sig_win = ReOpenAll(*draw_modus, *base_dpi);
  1187.   }
  1188.  
  1189.   refresh_draw_modus(*draw_modus, *base_dpi);
  1190.  
  1191. }
  1192.  
  1193.  
  1194. static void SaveConfig(int draw_modus, int base_dpi)
  1195. {
  1196.   FILE *f;
  1197.   struct config_struct cnf;
  1198.   
  1199.   memset(&cnf, 0, sizeof(cnf));
  1200.  
  1201.   cnf.magic       = CONFIG_FILE_MAGIC;
  1202.   cnf.version     = CONFIG_FILE_VERSION;
  1203.   cnf.use_blitter = use_blitter;
  1204.   cnf.invert_bmap = invert_bmap;
  1205.   cnf.base_dpi    = base_dpi;
  1206.   cnf.draw_modus  = draw_modus;
  1207.   cnf.use_pubscr  = use_pubscr;
  1208.   
  1209.   if (icon != NULL) {
  1210.     cnf.icon_x_pos  = icon->LeftEdge;
  1211.     cnf.icon_y_pos  = icon->TopEdge;
  1212.   }
  1213.   else {
  1214.     cnf.icon_x_pos  = icon_x_pos;
  1215.     cnf.icon_y_pos  = icon_y_pos;
  1216.   }
  1217.  
  1218.   if (win != NULL) {
  1219.     cnf.win_x_pos   = win->LeftEdge;
  1220.     cnf.win_y_pos   = win->TopEdge;
  1221.     cnf.win_width   = win->Width;
  1222.     cnf.win_height  = win->Height;
  1223.   }
  1224.   else {
  1225.     cnf.win_x_pos   = win_x_pos;
  1226.     cnf.win_y_pos   = win_y_pos;
  1227.     cnf.win_width   = win_width;
  1228.     cnf.win_height  = win_height;
  1229.   }
  1230.  
  1231.   f = OpenConfigFile("SpecialHost.config", "w");
  1232.   if (f == NULL) {
  1233.     pline("*** Can't save configuration!");
  1234.   }
  1235.  
  1236.   if (fwrite((char *)&cnf, sizeof(cnf), 1, f) != 1) {
  1237.     fclose(f);
  1238.     pline("*** Can't save configuration!");
  1239.     return;
  1240.   }
  1241.   fclose(f);
  1242. }
  1243.  
  1244.  
  1245.  
  1246. void main(int argc, char *argv[])
  1247. {
  1248.   UBYTE sig_icon = 0;
  1249.   ULONG sig_mask, sig_mask_win, sig_mask_icon, sig_ret, sig_port;
  1250.   long ret = 0;
  1251.   int draw_modus, base_dpi;
  1252.   int is_icon;
  1253.   long old_mics = 0, old_sec = 0;
  1254.  
  1255.   ifffile = NULL;
  1256.   bmap = NULL;
  1257.   is_icon = FALSE;
  1258.  
  1259.   icon = NULL;
  1260.   win  = NULL;
  1261.  
  1262.   win_x_pos  = WIN_X_KOO;
  1263.   win_y_pos  = WIN_Y_KOO;
  1264.   win_width  = WIN_WIDTH;
  1265.   win_height = WIN_HEIGHT;
  1266.   icon_x_pos = ICON_LEFT_EDGE;
  1267.   icon_y_pos = ICON_TOP_EDGE;
  1268.   
  1269.   base_dpi = 100;        /* 100 pixel per inch is the default! */
  1270.   draw_modus = DRAW_BORDER;    /* draw only a border is the default! */
  1271.  
  1272.  
  1273.   init_text();
  1274.  
  1275.   display_len = 55;        /* Vorabdefinitionen, die passen schon, bis generauere Infos da sind */
  1276.   lines_to_show = 7;
  1277.  
  1278.   height_char = HEIGHT_CHAR;    /* depents on used font */
  1279.   width_char = WIDTH_CHAR;
  1280.  
  1281.   pline(&(copyright[0]));    /* geht ins nicht vorhandene Fenster */
  1282.  
  1283.   swin.top->is_first = TRUE;    /* important! Initialisation after first pline    */
  1284.   swin.top->is_last = TRUE;    /* ^^^^^^^^^^                    */
  1285.  
  1286.   pline("Copyright© 90/91 Georg Heßmann. All Rights Reserved.");  
  1287.   pline("");
  1288.  
  1289.  
  1290.   if (FindPort(SPECIAL_PORT) != NULL) {
  1291.     Fatal(NOT_FIRST);
  1292.   }
  1293.  
  1294.   ReadConfig(&draw_modus, &base_dpi);
  1295.  
  1296.   OpenLib();
  1297.   OpenTopaz();
  1298.  
  1299.   if (!get_wb_screen_data(&win_title_height)) {
  1300.     win_title_height = 10;
  1301.   }
  1302.   if (win_title_height != 10) {
  1303.     short help = win_title_height - 10;
  1304.  
  1305.     Memory_Gad.TopEdge    += help;
  1306.     File_Gad.TopEdge    += help;
  1307.     Memory_B_Gad.TopEdge+= help;
  1308.     File_B_Gad.TopEdge    += help;
  1309.     Border_Gad.TopEdge    += help;
  1310.     Rect_Gad.TopEdge    += help;
  1311.     Bdpi_Gad.TopEdge    += help;
  1312.     toIcon_Gad.TopEdge    += help;
  1313.     Show_Gad.TopEdge    += help;
  1314.     Invert_Gad.TopEdge    += help;
  1315.     Blitter_Gad.TopEdge    += help;
  1316.   }
  1317.  
  1318.   sig_win = OpenWin();
  1319.   DrawWin();
  1320.   
  1321.   install_special_port(&special_port);
  1322.   sig_port = 1 << special_port->mp_SigBit;
  1323.  
  1324.  
  1325.   refresh_draw_modus(draw_modus, base_dpi);
  1326.  
  1327.   pline("Use blitter: %s, Invert bitmap: %s",
  1328.     (use_blitter) ? "on" : "off", (invert_bmap) ? "on" : "off");
  1329.  
  1330.   pline("First choose the draw mode and the base dpi...");
  1331.  
  1332.   /* now no IO!! (endcli closes the shell-window) */
  1333.   if (_Backstdout) {
  1334.     /* close _Backstdout only after init_text() !! */
  1335.     Close(_Backstdout);
  1336.     _Backstdout = NULL;
  1337.   }
  1338.   fclose(stderr);
  1339.  
  1340.  
  1341.   do {
  1342.     if (is_icon) {
  1343.       sig_mask_icon = 1 << sig_icon;
  1344.       sig_mask_win = 0L;
  1345.     }
  1346.     else {
  1347.       sig_mask_icon = 0L;
  1348.       sig_mask_win = 1 << sig_win;
  1349.     }
  1350.     sig_mask = sig_mask_win | sig_mask_icon | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_E | sig_port;
  1351.  
  1352.     sig_ret = Wait(sig_mask);
  1353.  
  1354.     if (sig_ret & SIGBREAKF_CTRL_E) {
  1355.       /* Nachfrage von ShowDVI, ob man denn von dem PubScr verschwinden moege... */
  1356.       if (is_os2 && use_pubscr) {
  1357.     use_pubscr = FALSE;
  1358.     ReOpenAll(draw_modus, base_dpi);
  1359.       }
  1360.     }
  1361.  
  1362.     /* *** Intui Message *** */
  1363.     if (!is_icon && (sig_ret & sig_mask_win)) {
  1364.       ret = WindowMessage(&draw_modus, &base_dpi);
  1365.       if (ret == 3) {
  1366.         is_icon = TRUE;
  1367.         ret = 0;
  1368.         /* uebernehme den Wert, der derzeit eingetragen ist */
  1369.     base_dpi = ((struct StringInfo *)(Bdpi_Gad.SpecialInfo))->LongInt;
  1370.         CloseWin();
  1371.         sig_icon = OpenIcon();
  1372.       }
  1373.     }
  1374.     if (is_icon && (sig_ret & sig_mask_icon)) {
  1375.       struct IntuiMessage *imess;
  1376.  
  1377.       while (is_icon && ((imess = (struct IntuiMessage *)GetMsg(icon->UserPort)) != NULL)) {
  1378.     if (DoubleClick(old_sec, old_mics, imess->Seconds, imess->Micros)) {
  1379.       ReplyMsg(&(imess->ExecMessage));
  1380.       while((imess = (struct IntuiMessage *)GetMsg(icon->UserPort)) != NULL) {
  1381.         ReplyMsg(&(imess->ExecMessage));    /* clear message port */
  1382.       }
  1383.       is_icon = FALSE;
  1384.       CloseIcon();
  1385.       sig_win = OpenWin();
  1386.       DrawWin();
  1387.           refresh_draw_modus(draw_modus, base_dpi);
  1388.       DisplayText();
  1389.     }
  1390.     else {
  1391.       old_sec = imess->Seconds;
  1392.       old_mics = imess->Micros;
  1393.       ReplyMsg(&(imess->ExecMessage));
  1394.     }
  1395.       }
  1396.     }
  1397.  
  1398.     /* *** Message from DVI-driver *** */
  1399.     if (sig_ret & sig_port) {
  1400.       /* Uebernehme den Wert aus dem Gadget... */
  1401.       base_dpi = ((struct StringInfo *)(Bdpi_Gad.SpecialInfo))->LongInt;
  1402.       ret = work_with_special(draw_modus, base_dpi);    /* in file SpecialHost.c */
  1403.     }
  1404.  
  1405.   } while (ret == 0 && !(sig_ret & SIGBREAKF_CTRL_C));
  1406.  
  1407.   close_all();
  1408. }
  1409.